package com.example.mygame;

import android.graphics.drawable.Drawable;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.ImageView;

public class BtnManager {

    private Button[][] btns = null ;//棋子按钮二维数组
    private ChessPiece[][] cps = null;//棋子二维数组

    private Round round = null;//回合

    private Drawable drawable_red = null;//红色棋子背景
    private Drawable drawable_blue = null;//蓝色棋子背景
    private Drawable drawable_white = null;//白色棋子背景

    private ImageView pointer_red = null;//红方操作指示
    private ImageView pointer_blue = null;//蓝方操作指示

    private int[][] camps = null;//阵营二维数组
    private int[][] poweroriginals = null;//阵营二维数组

    //-------------------------------------------------------------------------
    //开始游戏所需的重要操作
    /**
     * 构造函数
     * （必须）
     * @param btns 按钮二维数组，大小与cps相同
     * @param cps 棋子二维数组，大小与btns相同
     */
    public BtnManager(Button[][] btns, ChessPiece[][] cps) {
        if(btns.length!=cps.length||btns[0].length!=cps[0].length){
            Log.i("Error", "BtnManager: 初始化失败，由于按钮和棋子数组应大小不同");
            return;
        }
        this.btns = btns;
        this.cps = cps;
        round = new Round(cps);
    }

    /**
     * 设置操作指示器
     * （非必须）
     * （建议在 设置先手操作员SetOperator() 前使用）
     * @param pointer_red 图片红方指示器
     * @param pointer_blue 图片蓝方指示器
     */
    public void SetPointer(ImageView pointer_red,ImageView pointer_blue){
        this.pointer_red = pointer_red;
        this.pointer_blue = pointer_blue;
    }

    /**
     * 设置先手操作员
     *  （必须）
     *  （建议在 设置操作指示器SetPointer() 后使用）
     * @param operator 操作员阵营id
     */
    public void SetOperator(int operator) {
        round.setOperator(operator);

        if(pointer_red == null||pointer_blue == null){
            return;
        }

        if(operator == ChessPiece.CAMP_RED){
            pointer_red.setVisibility(View.VISIBLE);
            pointer_blue.setVisibility(View.INVISIBLE);
        }
        else if(operator == ChessPiece.CAMP_BLUE){
            pointer_red.setVisibility(View.INVISIBLE);
            pointer_blue.setVisibility(View.VISIBLE);
        }
    }


    /**
     * 设置按钮背景资源
     * （必须）
     * （建议在 初始化回合InitChessboard() 前使用）
     * @param drawables 背景资源数组，长度为3
     */
    public void SetDrawable(Drawable[] drawables)
    {
        if(drawables.length<3){
            Log.i("Error", "SetDrawable: 设置按钮背景资源失败，传入数组长度应等于3");
            return;
        }
        drawable_red = drawables[0];
        drawable_blue = drawables[1];
        drawable_white = drawables[2];
    }

    /**
     * 初始化回合
     * （必须）
     * （建议在 设置按钮背景资源SetDrawable() 后使用）
     * @param camps 阵营二维数组
     * @param poweroriginals 当前战力二维数组
     */
    public void InitChessboard(int[][] camps,int[][] poweroriginals){
        if(camps.length != cps.length || poweroriginals.length != cps.length){
            Log.i("Error", "InitChessboard: 初始化回合失败，传入数组的大小应均与棋子数组相同");
            return;
        }
        this.camps = camps;
        this.poweroriginals = poweroriginals;
        SetAllCamp(camps);
        SetAllPowerOriginal(poweroriginals);
        UpdataBtnStyle();
    }

    /**
     * 使用储存的初始化信息重置棋盘
     * 重置先手
     * 重置阵营
     * 重置原始战力和当前战力
     * 清空恢复倒计时
     * 刷新按钮背景
     */
    public void ResetChessboard(){
        SetOperator(ChessPiece.CAMP_RED);
        SetAllCamp(camps);
        SetAllPowerOriginal(poweroriginals);
        ClearAllCountDown();
        UpdataBtnStyle();
    }

    //-------------------------------------------------------------------------
    //回合操作
    /**
     * 运行回合（按钮）
     * @param operate_btn_A 操作棋子A按钮
     * @param operate_btn_B 操作棋子B按钮
     */
    public boolean RunRound(Button operate_btn_A, Button operate_btn_B){
        return RunRound(Btn2CP(operate_btn_A),Btn2CP(operate_btn_B));
    }

    /**
     * 运行回合（棋子）
     * @param operate_cp_A 主动方棋子
     * @param operate_cp_B 被动方棋子
     */
    public boolean RunRound(ChessPiece operate_cp_A, ChessPiece operate_cp_B){
        if(!round.Run(operate_cp_A, operate_cp_B)) return false;
        UpdataBtnStyle();
        ChangePointer();
        return true;
    }

    /**
     * 获取获胜者
     * @return  返回获胜者阵营id,尚未有一方获胜则返回0
     */
    public int GetWinner(){
        return round.GetWinner();
    }
    //-------------------------------------------------------------------------
    //回合操作细节内容
    /**
     * 将根据按钮找到到对应棋子
     * @param btn 按钮
     * @return 棋子
     */
    private ChessPiece Btn2CP(Button btn){
        String tag = (String) btn.getTag();
        String[] temp = tag.split("_");
        int x = Integer.parseInt(temp[0]);
        x = Math.max(0,x);
        x = Math.min(cps.length,x);
        int y = Integer.parseInt(temp[1]);
        y = Math.max(0,y);
        y = Math.min(cps[0].length,y);
        return cps[x][y];
    }


    /**
     * 更新所有按钮背景显示
     */
    public void UpdataBtnStyle()
    {
        int[][] camps = GetAllCamp();
        int[][] power_current = GetAllPower_current();
        int[][] power_origin = GetAllPower_original();
        for (int i = 0; i < cps.length; i++) {
            for (int j = 0; j < cps[0].length; j++) {
                String text = power_current[i][j] + "/" + power_origin[i][j];
                ChangeText(text,btns[i][j]);
                //计划：根据阵营设置按钮背景
                ChangeBackground(camps[i][j],btns[i][j]);
                btns[i][j].setSelected(false);
            }
        }
    }

    /**
     * 改变操作指示器
     * 如从 红可见蓝不可见 变成 蓝可见红不可见
     */
    private void ChangePointer(){
        if (pointer_red.getVisibility() == View.VISIBLE){
            pointer_red.setVisibility(View.INVISIBLE);
        }
        else{
            pointer_red.setVisibility(View.VISIBLE);
        }
        if (pointer_blue.getVisibility() == View.VISIBLE){
            pointer_blue.setVisibility(View.INVISIBLE);
        }
        else{
            pointer_blue.setVisibility(View.VISIBLE);
        }
    }
    //-------------------------------------------------------------------------
    //更新按钮显示的细节内容
    /**
     * 设置按钮背景
     * @param camp 棋子阵营
     * @param btn 按钮
     */
    public void ChangeBackground(int camp, Button btn){
        switch (camp){
            case ChessPiece.CAMP_RED:   btn.setBackground(drawable_red.getConstantState().newDrawable().mutate());  break;
            case ChessPiece.CAMP_BLUE:  btn.setBackground(drawable_blue.getConstantState().newDrawable().mutate());   break;
            case ChessPiece.CAMP_WHITE: btn.setBackground(drawable_white.getConstantState().newDrawable().mutate());  break;
            default:    break;
        }
    }

    /**
     * 设置按钮文字
     * @param text 希望按钮显示的文字
     * @param btn 按钮
     */
    public void ChangeText(String text,Button btn){
        btn.setText(text);
    }

    //-------------------------------------------------------------------------
    //批量获取

    /**
     * 获取所有阵营
     * @return 阵营二维数组
     */
    public int[][] GetAllCamp(){
        return round.GetAllCamp();
    }

    /**
     * 获取所有当前战力
     * @return 当前战力二维数组
     */
    public int[][] GetAllPower_current(){
        return round.GetAllPower_current();
    }

    /**
     * 获取所有原始战力
     * @return 原始战力二维数组
     */
    public int[][] GetAllPower_original(){
        return round.GetAllPower_original();
    }



    //-------------------------------------------------------------------------
    //批量设置

    /**
     * 批量设置阵营
     * @param camps 阵营二维数组
     */
    public void SetAllCamp(int[][] camps) {
        round.SetAllCamp(camps);
    }

    /**
     * 批量设置原始战力
     * @param poweroriginals
     */
    public void SetAllPowerOriginal(int[][] poweroriginals){
        round.SetAllPowerOriginal(poweroriginals);
    }

    /**
     * 批量清空倒计时
     */
    public void ClearAllCountDown(){
        round.ClearAllCountDown();
    }


}
